package com.ourteam.product.ui.dao;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;
import org.apache.commons.lang.StringUtils;

/**
 * Template Name : DAO查询对象 Template Version : 1 Template Last Modfiy Date : Sat Aug 19 10:06:32 CST
 * 2017 Auto Generate Date : 2018-12-14 15:15:15 Warning ! This file will be overwrite when
 * regenerate !
 */
public class ProductUIImageDAOQueryBean extends BaseQueryBean {

  public ProductUIImageDAOQueryBean() {
    super();
  }

  public ProductUIImageDAOQueryBean(BaseQueryBean aQueryBean) {
    super(aQueryBean);
  }

  public ProductUIImageDAOQueryBean(BaseQueryBean aQueryBean, Map tableReplaceMap) {
    super(aQueryBean, tableReplaceMap);
  }

  public Criteria createCriteria() {

    Criteria criteria = createCriteriaInternal();
    if (oredCriteria.size() == 0) {
      oredCriteria.add(criteria);
    }
    return criteria;
  }

  protected Criteria createCriteriaInternal() {
    return new Criteria(this);
  }

  public void addIdSelectProperty() {
    addIdSelectProperty("id");
  }

  public void addIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUIImageDAO.Id, aAlias);
    } else {
      addSelectProperty(IProductUIImageDAO.Id, "id");
    }
  }

  public void addDomainIdSelectProperty() {
    addDomainIdSelectProperty("domainId");
  }

  public void addDomainIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUIImageDAO.DomainId, aAlias);
    } else {
      addSelectProperty(IProductUIImageDAO.DomainId, "domainId");
    }
  }

  public void addImageCodeSelectProperty() {
    addImageCodeSelectProperty("imageCode");
  }

  public void addImageCodeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUIImageDAO.ImageCode, aAlias);
    } else {
      addSelectProperty(IProductUIImageDAO.ImageCode, "imageCode");
    }
  }

  public void addImagePathSelectProperty() {
    addImagePathSelectProperty("imagePath");
  }

  public void addImagePathSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUIImageDAO.ImagePath, aAlias);
    } else {
      addSelectProperty(IProductUIImageDAO.ImagePath, "imagePath");
    }
  }

  public void addImageWidthSelectProperty() {
    addImageWidthSelectProperty("imageWidth");
  }

  public void addImageWidthSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUIImageDAO.ImageWidth, aAlias);
    } else {
      addSelectProperty(IProductUIImageDAO.ImageWidth, "imageWidth");
    }
  }

  public void addImageHeightSelectProperty() {
    addImageHeightSelectProperty("imageHeight");
  }

  public void addImageHeightSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUIImageDAO.ImageHeight, aAlias);
    } else {
      addSelectProperty(IProductUIImageDAO.ImageHeight, "imageHeight");
    }
  }

  public void addImageTypeSelectProperty() {
    addImageTypeSelectProperty("imageType");
  }

  public void addImageTypeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUIImageDAO.ImageType, aAlias);
    } else {
      addSelectProperty(IProductUIImageDAO.ImageType, "imageType");
    }
  }

  public void addLastModifyUserSelectProperty() {
    addLastModifyUserSelectProperty("lastModifyUser");
  }

  public void addLastModifyUserSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUIImageDAO.LastModifyUser, aAlias);
    } else {
      addSelectProperty(IProductUIImageDAO.LastModifyUser, "lastModifyUser");
    }
  }

  public void addLastModifyTimeSelectProperty() {
    addLastModifyTimeSelectProperty("lastModifyTime");
  }

  public void addLastModifyTimeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUIImageDAO.LastModifyTime, aAlias);
    } else {
      addSelectProperty(IProductUIImageDAO.LastModifyTime, "lastModifyTime");
    }
  }

  public void addStatusSelectProperty() {
    addStatusSelectProperty("status");
  }

  public void addStatusSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUIImageDAO.Status, aAlias);
    } else {
      addSelectProperty(IProductUIImageDAO.Status, "status");
    }
  }

  public void addRemarksSelectProperty() {
    addRemarksSelectProperty("remarks");
  }

  public void addRemarksSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUIImageDAO.Remarks, aAlias);
    } else {
      addSelectProperty(IProductUIImageDAO.Remarks, "remarks");
    }
  }

  public void addImageContentSelectProperty() {
    addImageContentSelectProperty("imageContent");
  }

  public void addImageContentSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUIImageDAO.ImageContent, aAlias);
    } else {
      addSelectProperty(IProductUIImageDAO.ImageContent, "imageContent");
    }
  }

  public void addDomainCodeSelectProperty() {
    addDomainCodeSelectProperty("domainCode");
  }

  public void addDomainCodeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUIImageDAO.DomainCode, aAlias);
    } else {
      addSelectProperty(IProductUIImageDAO.DomainCode, "domainCode");
    }
  }

  public void addDomainNameSelectProperty() {
    addDomainNameSelectProperty("domainName");
  }

  public void addDomainNameSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IProductUIImageDAO.DomainName, aAlias);
    } else {
      addSelectProperty(IProductUIImageDAO.DomainName, "domainName");
    }
  }

  public void addAllSelectProperties() {

    addIdSelectProperty();

    addDomainIdSelectProperty();

    addImageCodeSelectProperty();

    addImagePathSelectProperty();

    addImageWidthSelectProperty();

    addImageHeightSelectProperty();

    addImageTypeSelectProperty();

    addLastModifyUserSelectProperty();

    addLastModifyTimeSelectProperty();

    addStatusSelectProperty();

    addRemarksSelectProperty();

    addImageContentSelectProperty();

    addDomainCodeSelectProperty();

    addDomainNameSelectProperty();
  }

  public static class Criteria extends BaseWhereCriterion<ProductUIImageDAOQueryBean> {

    protected Criteria(ProductUIImageDAOQueryBean aParentObject) {
      super(aParentObject);
    }

    public Criteria andIdIsNull() {
      addCriterion(IProductUIImageDAO.Id + " is null");
      return this;
    }

    public Criteria andIdIsNotNull() {
      addCriterion(IProductUIImageDAO.Id + " is not null");
      return this;
    }

    public Criteria andIdIsNotEmpty() {
      addCriterion(IProductUIImageDAO.Id + " is not null AND " + IProductUIImageDAO.Id + " <> ''");
      return this;
    }

    public Criteria andIdIsEmpty() {
      addCriterion("(" + IProductUIImageDAO.Id + " is null OR " + IProductUIImageDAO.Id + " = '')");
      return this;
    }

    public Criteria andIdEqualTo(long value) {
      return andIdEqualTo(Long.valueOf(value));
    }

    public Criteria andIdEqualTo(java.lang.Long value) {

      addCriterion(IProductUIImageDAO.Id + " = ", value, "id");
      return this;
    }

    public Criteria andIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Id);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Id + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotEqualTo(long value) {
      return andIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andIdNotEqualTo(java.lang.Long value) {

      addCriterion(IProductUIImageDAO.Id + " <>", value, "id");
      return this;
    }

    public Criteria andIdNotEqualToOrIsNull(long value) {
      return andIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IProductUIImageDAO.Id + " is null OR " + IProductUIImageDAO.Id + " <>", value, "id");
      return this;
    }

    public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Id);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Id + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThan(long value) {
      return andIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andIdGreaterThan(java.lang.Long value) {

      addCriterion(IProductUIImageDAO.Id + " >", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Id);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Id + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(long value) {
      return andIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IProductUIImageDAO.Id + " >=", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Id);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Id + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThan(long value) {
      return andIdLessThan(Long.valueOf(value));
    }

    public Criteria andIdLessThan(java.lang.Long value) {

      addCriterion(IProductUIImageDAO.Id + " <", value, "id");
      return this;
    }

    public Criteria andIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Id);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Id + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(long value) {
      return andIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IProductUIImageDAO.Id + " <=", value, "id");
      return this;
    }

    public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Id);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Id + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdIn(long[] values) {
      if (values.length == 1) {
        return andIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IProductUIImageDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IProductUIImageDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andIdEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andIdEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.Id + " in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.Id + " not in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Id + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Id + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdBetween(long value1, long value2) {
      addCriterion(IProductUIImageDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IProductUIImageDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(long value1, long value2) {
      addCriterion(IProductUIImageDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IProductUIImageDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andDomainIdIsNull() {
      addCriterion(IProductUIImageDAO.DomainId + " is null");
      return this;
    }

    public Criteria andDomainIdIsNotNull() {
      addCriterion(IProductUIImageDAO.DomainId + " is not null");
      return this;
    }

    public Criteria andDomainIdIsNotEmpty() {
      addCriterion(
          IProductUIImageDAO.DomainId
              + " is not null AND "
              + IProductUIImageDAO.DomainId
              + " <> ''");
      return this;
    }

    public Criteria andDomainIdIsEmpty() {
      addCriterion(
          "("
              + IProductUIImageDAO.DomainId
              + " is null OR "
              + IProductUIImageDAO.DomainId
              + " = '')");
      return this;
    }

    public Criteria andDomainIdEqualTo(long value) {
      return andDomainIdEqualTo(Long.valueOf(value));
    }

    public Criteria andDomainIdEqualTo(java.lang.Long value) {

      addCriterion(IProductUIImageDAO.DomainId + " = ", value, "domainId");
      return this;
    }

    public Criteria andDomainIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainId);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainIdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainId + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainIdNotEqualTo(long value) {
      return andDomainIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andDomainIdNotEqualTo(java.lang.Long value) {

      addCriterion(IProductUIImageDAO.DomainId + " <>", value, "domainId");
      return this;
    }

    public Criteria andDomainIdNotEqualToOrIsNull(long value) {
      return andDomainIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andDomainIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IProductUIImageDAO.DomainId + " is null OR " + IProductUIImageDAO.DomainId + " <>",
          value,
          "domainId");
      return this;
    }

    public Criteria andDomainIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainId);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainIdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainId + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainIdGreaterThan(long value) {
      return andDomainIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andDomainIdGreaterThan(java.lang.Long value) {

      addCriterion(IProductUIImageDAO.DomainId + " >", value, "domainId");
      return this;
    }

    public Criteria andDomainIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainId);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainIdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainId + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainIdGreaterThanOrEqualTo(long value) {
      return andDomainIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andDomainIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IProductUIImageDAO.DomainId + " >=", value, "domainId");
      return this;
    }

    public Criteria andDomainIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainId);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainId + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainIdLessThan(long value) {
      return andDomainIdLessThan(Long.valueOf(value));
    }

    public Criteria andDomainIdLessThan(java.lang.Long value) {

      addCriterion(IProductUIImageDAO.DomainId + " <", value, "domainId");
      return this;
    }

    public Criteria andDomainIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainId);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainIdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainId + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainIdLessThanOrEqualTo(long value) {
      return andDomainIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andDomainIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IProductUIImageDAO.DomainId + " <=", value, "domainId");
      return this;
    }

    public Criteria andDomainIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainId);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainId + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainIdIn(long[] values) {
      if (values.length == 1) {
        return andDomainIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IProductUIImageDAO.DomainId + " in", values, "domainId");
        return this;
      }
    }

    public Criteria andDomainIdNotIn(long[] values) {
      if (values.length == 1) {
        return andDomainIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IProductUIImageDAO.DomainId + " not in", values, "domainId");
        return this;
      }
    }

    public Criteria andDomainIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andDomainIdEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.DomainId + " in", values, "domainId");
        return this;
      }
    }

    public Criteria andDomainIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andDomainIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.DomainId + " not in", values, "domainId");
        return this;
      }
    }

    public Criteria andDomainIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andDomainIdEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.DomainId + " in", Arrays.asList(values), "domainId");
        return this;
      }
    }

    public Criteria andDomainIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andDomainIdNotEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.DomainId + " not in", Arrays.asList(values), "domainId");
        return this;
      }
    }

    public Criteria andDomainIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainId + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainIdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainId + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainIdBetween(long value1, long value2) {
      addCriterion(IProductUIImageDAO.DomainId + " between", value1, value2, "domainId");
      return this;
    }

    public Criteria andDomainIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IProductUIImageDAO.DomainId + " between", value1, value2, "domainId");
      return this;
    }

    public Criteria andDomainIdNotBetween(long value1, long value2) {
      addCriterion(IProductUIImageDAO.DomainId + " not between", value1, value2, "domainId");
      return this;
    }

    public Criteria andDomainIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IProductUIImageDAO.DomainId + " not between", value1, value2, "domainId");
      return this;
    }

    public Criteria andImageCodeIsNull() {
      addCriterion(IProductUIImageDAO.ImageCode + " is null");
      return this;
    }

    public Criteria andImageCodeIsNotNull() {
      addCriterion(IProductUIImageDAO.ImageCode + " is not null");
      return this;
    }

    public Criteria andImageCodeIsNotEmpty() {
      addCriterion(
          IProductUIImageDAO.ImageCode
              + " is not null AND "
              + IProductUIImageDAO.ImageCode
              + " <> ''");
      return this;
    }

    public Criteria andImageCodeIsEmpty() {
      addCriterion(
          "("
              + IProductUIImageDAO.ImageCode
              + " is null OR "
              + IProductUIImageDAO.ImageCode
              + " = '')");
      return this;
    }

    public Criteria andImageCodeEqualTo(String value) {

      addCriterion(IProductUIImageDAO.ImageCode + " = ", value, "imageCode");
      return this;
    }

    public Criteria andImageCodeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageCode);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageCodeEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageCode + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageCodeNotEqualTo(String value) {

      addCriterion(IProductUIImageDAO.ImageCode + " <>", value, "imageCode");
      return this;
    }

    public Criteria andImageCodeNotEqualToOrIsNull(String value) {

      addCriterion(
          IProductUIImageDAO.ImageCode + " is null OR " + IProductUIImageDAO.ImageCode + " <>",
          value,
          "imageCode");
      return this;
    }

    public Criteria andImageCodeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageCode);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageCodeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageCode + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageCodeGreaterThan(String value) {

      addCriterion(IProductUIImageDAO.ImageCode + " >", value, "imageCode");
      return this;
    }

    public Criteria andImageCodeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageCode);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageCodeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageCode + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageCodeGreaterThanOrEqualTo(String value) {

      addCriterion(IProductUIImageDAO.ImageCode + " >=", value, "imageCode");
      return this;
    }

    public Criteria andImageCodeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageCode);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageCodeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageCode + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageCodeLessThan(String value) {

      addCriterion(IProductUIImageDAO.ImageCode + " <", value, "imageCode");
      return this;
    }

    public Criteria andImageCodeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageCode);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageCodeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageCode + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageCodeLessThanOrEqualTo(String value) {

      addCriterion(IProductUIImageDAO.ImageCode + " <=", value, "imageCode");
      return this;
    }

    public Criteria andImageCodeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageCode);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageCodeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageCode + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageCodeLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUIImageDAO.ImageCode + " like", buffer.toString(), "imageCode");
      return this;
    }

    public Criteria andImageCodeNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUIImageDAO.ImageCode + " not like", buffer.toString(), "imageCode");
      return this;
    }

    public Criteria andImageCodeIn(List<String> values) {

      if (values.size() == 1) {
        return andImageCodeEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.ImageCode + " in", values, "imageCode");
        return this;
      }
    }

    public Criteria andImageCodeNotIn(List<String> values) {
      if (values.size() == 1) {
        return andImageCodeNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.ImageCode + " not in", values, "imageCode");
        return this;
      }
    }

    public Criteria andImageCodeIn(String[] values) {

      if (values.length == 1) {
        return andImageCodeEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.ImageCode + " in", Arrays.asList(values), "imageCode");
        return this;
      }
    }

    public Criteria andImageCodeNotIn(String[] values) {
      if (values.length == 1) {
        return andImageCodeNotEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.ImageCode + " not in", Arrays.asList(values), "imageCode");
        return this;
      }
    }

    public Criteria andImageCodeIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageCode + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageCodeNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageCode + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageCodeBetween(String value1, String value2) {
      addCriterion(IProductUIImageDAO.ImageCode + " between", value1, value2, "imageCode");
      return this;
    }

    public Criteria andImageCodeNotBetween(String value1, String value2) {
      addCriterion(IProductUIImageDAO.ImageCode + " not between", value1, value2, "imageCode");
      return this;
    }

    public Criteria andImagePathIsNull() {
      addCriterion(IProductUIImageDAO.ImagePath + " is null");
      return this;
    }

    public Criteria andImagePathIsNotNull() {
      addCriterion(IProductUIImageDAO.ImagePath + " is not null");
      return this;
    }

    public Criteria andImagePathIsNotEmpty() {
      addCriterion(
          IProductUIImageDAO.ImagePath
              + " is not null AND "
              + IProductUIImageDAO.ImagePath
              + " <> ''");
      return this;
    }

    public Criteria andImagePathIsEmpty() {
      addCriterion(
          "("
              + IProductUIImageDAO.ImagePath
              + " is null OR "
              + IProductUIImageDAO.ImagePath
              + " = '')");
      return this;
    }

    public Criteria andImagePathEqualTo(String value) {

      addCriterion(IProductUIImageDAO.ImagePath + " = ", value, "imagePath");
      return this;
    }

    public Criteria andImagePathEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImagePath);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImagePathEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImagePath + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andImagePathNotEqualTo(String value) {

      addCriterion(IProductUIImageDAO.ImagePath + " <>", value, "imagePath");
      return this;
    }

    public Criteria andImagePathNotEqualToOrIsNull(String value) {

      addCriterion(
          IProductUIImageDAO.ImagePath + " is null OR " + IProductUIImageDAO.ImagePath + " <>",
          value,
          "imagePath");
      return this;
    }

    public Criteria andImagePathNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImagePath);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImagePathNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImagePath + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andImagePathGreaterThan(String value) {

      addCriterion(IProductUIImageDAO.ImagePath + " >", value, "imagePath");
      return this;
    }

    public Criteria andImagePathGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImagePath);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImagePathGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImagePath + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andImagePathGreaterThanOrEqualTo(String value) {

      addCriterion(IProductUIImageDAO.ImagePath + " >=", value, "imagePath");
      return this;
    }

    public Criteria andImagePathGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImagePath);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImagePathGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImagePath + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andImagePathLessThan(String value) {

      addCriterion(IProductUIImageDAO.ImagePath + " <", value, "imagePath");
      return this;
    }

    public Criteria andImagePathLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImagePath);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImagePathLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImagePath + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andImagePathLessThanOrEqualTo(String value) {

      addCriterion(IProductUIImageDAO.ImagePath + " <=", value, "imagePath");
      return this;
    }

    public Criteria andImagePathLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImagePath);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImagePathLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImagePath + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andImagePathLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUIImageDAO.ImagePath + " like", buffer.toString(), "imagePath");
      return this;
    }

    public Criteria andImagePathNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUIImageDAO.ImagePath + " not like", buffer.toString(), "imagePath");
      return this;
    }

    public Criteria andImagePathIn(List<String> values) {

      if (values.size() == 1) {
        return andImagePathEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.ImagePath + " in", values, "imagePath");
        return this;
      }
    }

    public Criteria andImagePathNotIn(List<String> values) {
      if (values.size() == 1) {
        return andImagePathNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.ImagePath + " not in", values, "imagePath");
        return this;
      }
    }

    public Criteria andImagePathIn(String[] values) {

      if (values.length == 1) {
        return andImagePathEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.ImagePath + " in", Arrays.asList(values), "imagePath");
        return this;
      }
    }

    public Criteria andImagePathNotIn(String[] values) {
      if (values.length == 1) {
        return andImagePathNotEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.ImagePath + " not in", Arrays.asList(values), "imagePath");
        return this;
      }
    }

    public Criteria andImagePathIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImagePath + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andImagePathNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImagePath + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andImagePathBetween(String value1, String value2) {
      addCriterion(IProductUIImageDAO.ImagePath + " between", value1, value2, "imagePath");
      return this;
    }

    public Criteria andImagePathNotBetween(String value1, String value2) {
      addCriterion(IProductUIImageDAO.ImagePath + " not between", value1, value2, "imagePath");
      return this;
    }

    public Criteria andImageWidthIsNull() {
      addCriterion(IProductUIImageDAO.ImageWidth + " is null");
      return this;
    }

    public Criteria andImageWidthIsNotNull() {
      addCriterion(IProductUIImageDAO.ImageWidth + " is not null");
      return this;
    }

    public Criteria andImageWidthIsNotEmpty() {
      addCriterion(
          IProductUIImageDAO.ImageWidth
              + " is not null AND "
              + IProductUIImageDAO.ImageWidth
              + " <> ''");
      return this;
    }

    public Criteria andImageWidthIsEmpty() {
      addCriterion(
          "("
              + IProductUIImageDAO.ImageWidth
              + " is null OR "
              + IProductUIImageDAO.ImageWidth
              + " = '')");
      return this;
    }

    public Criteria andImageWidthEqualTo(int value) {
      return andImageWidthEqualTo(Integer.valueOf(value));
    }

    public Criteria andImageWidthEqualTo(java.lang.Integer value) {

      addCriterion(IProductUIImageDAO.ImageWidth + " = ", value, "imageWidth");
      return this;
    }

    public Criteria andImageWidthEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageWidth);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageWidthEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageWidth + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageWidthNotEqualTo(int value) {
      return andImageWidthNotEqualTo(Integer.valueOf(value));
    }

    public Criteria andImageWidthNotEqualTo(java.lang.Integer value) {

      addCriterion(IProductUIImageDAO.ImageWidth + " <>", value, "imageWidth");
      return this;
    }

    public Criteria andImageWidthNotEqualToOrIsNull(int value) {
      return andImageWidthNotEqualToOrIsNull(Integer.valueOf(value));
    }

    public Criteria andImageWidthNotEqualToOrIsNull(java.lang.Integer value) {

      addCriterion(
          IProductUIImageDAO.ImageWidth + " is null OR " + IProductUIImageDAO.ImageWidth + " <>",
          value,
          "imageWidth");
      return this;
    }

    public Criteria andImageWidthNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageWidth);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageWidthNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageWidth + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageWidthGreaterThan(int value) {
      return andImageWidthGreaterThan(Integer.valueOf(value));
    }

    public Criteria andImageWidthGreaterThan(java.lang.Integer value) {

      addCriterion(IProductUIImageDAO.ImageWidth + " >", value, "imageWidth");
      return this;
    }

    public Criteria andImageWidthGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageWidth);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageWidthGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageWidth + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageWidthGreaterThanOrEqualTo(int value) {
      return andImageWidthGreaterThanOrEqualTo(Integer.valueOf(value));
    }

    public Criteria andImageWidthGreaterThanOrEqualTo(java.lang.Integer value) {

      addCriterion(IProductUIImageDAO.ImageWidth + " >=", value, "imageWidth");
      return this;
    }

    public Criteria andImageWidthGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageWidth);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageWidthGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageWidth + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageWidthLessThan(int value) {
      return andImageWidthLessThan(Integer.valueOf(value));
    }

    public Criteria andImageWidthLessThan(java.lang.Integer value) {

      addCriterion(IProductUIImageDAO.ImageWidth + " <", value, "imageWidth");
      return this;
    }

    public Criteria andImageWidthLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageWidth);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageWidthLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageWidth + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageWidthLessThanOrEqualTo(int value) {
      return andImageWidthLessThanOrEqualTo(Integer.valueOf(value));
    }

    public Criteria andImageWidthLessThanOrEqualTo(java.lang.Integer value) {

      addCriterion(IProductUIImageDAO.ImageWidth + " <=", value, "imageWidth");
      return this;
    }

    public Criteria andImageWidthLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageWidth);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageWidthLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageWidth + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageWidthIn(int[] values) {
      if (values.length == 1) {
        return andImageWidthEqualTo((java.lang.Integer) values[0]);
      } else {
        addCriterion(IProductUIImageDAO.ImageWidth + " in", values, "imageWidth");
        return this;
      }
    }

    public Criteria andImageWidthNotIn(int[] values) {
      if (values.length == 1) {
        return andImageWidthNotEqualTo((java.lang.Integer) values[0]);
      } else {
        addCriterion(IProductUIImageDAO.ImageWidth + " not in", values, "imageWidth");
        return this;
      }
    }

    public Criteria andImageWidthIn(List<java.lang.Integer> values) {

      if (values.size() == 1) {
        return andImageWidthEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.ImageWidth + " in", values, "imageWidth");
        return this;
      }
    }

    public Criteria andImageWidthNotIn(List<java.lang.Integer> values) {
      if (values.size() == 1) {
        return andImageWidthNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.ImageWidth + " not in", values, "imageWidth");
        return this;
      }
    }

    public Criteria andImageWidthIn(java.lang.Integer[] values) {

      if (values.length == 1) {
        return andImageWidthEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.ImageWidth + " in", Arrays.asList(values), "imageWidth");
        return this;
      }
    }

    public Criteria andImageWidthNotIn(java.lang.Integer[] values) {
      if (values.length == 1) {
        return andImageWidthNotEqualTo(values[0]);
      } else {
        addCriterion(
            IProductUIImageDAO.ImageWidth + " not in", Arrays.asList(values), "imageWidth");
        return this;
      }
    }

    public Criteria andImageWidthIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageWidth + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageWidthNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageWidth + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageWidthBetween(int value1, int value2) {
      addCriterion(IProductUIImageDAO.ImageWidth + " between", value1, value2, "imageWidth");
      return this;
    }

    public Criteria andImageWidthBetween(java.lang.Integer value1, java.lang.Integer value2) {
      addCriterion(IProductUIImageDAO.ImageWidth + " between", value1, value2, "imageWidth");
      return this;
    }

    public Criteria andImageWidthNotBetween(int value1, int value2) {
      addCriterion(IProductUIImageDAO.ImageWidth + " not between", value1, value2, "imageWidth");
      return this;
    }

    public Criteria andImageWidthNotBetween(java.lang.Integer value1, java.lang.Integer value2) {
      addCriterion(IProductUIImageDAO.ImageWidth + " not between", value1, value2, "imageWidth");
      return this;
    }

    public Criteria andImageHeightIsNull() {
      addCriterion(IProductUIImageDAO.ImageHeight + " is null");
      return this;
    }

    public Criteria andImageHeightIsNotNull() {
      addCriterion(IProductUIImageDAO.ImageHeight + " is not null");
      return this;
    }

    public Criteria andImageHeightIsNotEmpty() {
      addCriterion(
          IProductUIImageDAO.ImageHeight
              + " is not null AND "
              + IProductUIImageDAO.ImageHeight
              + " <> ''");
      return this;
    }

    public Criteria andImageHeightIsEmpty() {
      addCriterion(
          "("
              + IProductUIImageDAO.ImageHeight
              + " is null OR "
              + IProductUIImageDAO.ImageHeight
              + " = '')");
      return this;
    }

    public Criteria andImageHeightEqualTo(int value) {
      return andImageHeightEqualTo(Integer.valueOf(value));
    }

    public Criteria andImageHeightEqualTo(java.lang.Integer value) {

      addCriterion(IProductUIImageDAO.ImageHeight + " = ", value, "imageHeight");
      return this;
    }

    public Criteria andImageHeightEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageHeight);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageHeightEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageHeight + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageHeightNotEqualTo(int value) {
      return andImageHeightNotEqualTo(Integer.valueOf(value));
    }

    public Criteria andImageHeightNotEqualTo(java.lang.Integer value) {

      addCriterion(IProductUIImageDAO.ImageHeight + " <>", value, "imageHeight");
      return this;
    }

    public Criteria andImageHeightNotEqualToOrIsNull(int value) {
      return andImageHeightNotEqualToOrIsNull(Integer.valueOf(value));
    }

    public Criteria andImageHeightNotEqualToOrIsNull(java.lang.Integer value) {

      addCriterion(
          IProductUIImageDAO.ImageHeight + " is null OR " + IProductUIImageDAO.ImageHeight + " <>",
          value,
          "imageHeight");
      return this;
    }

    public Criteria andImageHeightNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageHeight);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageHeightNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageHeight + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageHeightGreaterThan(int value) {
      return andImageHeightGreaterThan(Integer.valueOf(value));
    }

    public Criteria andImageHeightGreaterThan(java.lang.Integer value) {

      addCriterion(IProductUIImageDAO.ImageHeight + " >", value, "imageHeight");
      return this;
    }

    public Criteria andImageHeightGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageHeight);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageHeightGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageHeight + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageHeightGreaterThanOrEqualTo(int value) {
      return andImageHeightGreaterThanOrEqualTo(Integer.valueOf(value));
    }

    public Criteria andImageHeightGreaterThanOrEqualTo(java.lang.Integer value) {

      addCriterion(IProductUIImageDAO.ImageHeight + " >=", value, "imageHeight");
      return this;
    }

    public Criteria andImageHeightGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageHeight);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageHeightGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageHeight + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageHeightLessThan(int value) {
      return andImageHeightLessThan(Integer.valueOf(value));
    }

    public Criteria andImageHeightLessThan(java.lang.Integer value) {

      addCriterion(IProductUIImageDAO.ImageHeight + " <", value, "imageHeight");
      return this;
    }

    public Criteria andImageHeightLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageHeight);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageHeightLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageHeight + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageHeightLessThanOrEqualTo(int value) {
      return andImageHeightLessThanOrEqualTo(Integer.valueOf(value));
    }

    public Criteria andImageHeightLessThanOrEqualTo(java.lang.Integer value) {

      addCriterion(IProductUIImageDAO.ImageHeight + " <=", value, "imageHeight");
      return this;
    }

    public Criteria andImageHeightLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageHeight);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageHeightLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageHeight + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageHeightIn(int[] values) {
      if (values.length == 1) {
        return andImageHeightEqualTo((java.lang.Integer) values[0]);
      } else {
        addCriterion(IProductUIImageDAO.ImageHeight + " in", values, "imageHeight");
        return this;
      }
    }

    public Criteria andImageHeightNotIn(int[] values) {
      if (values.length == 1) {
        return andImageHeightNotEqualTo((java.lang.Integer) values[0]);
      } else {
        addCriterion(IProductUIImageDAO.ImageHeight + " not in", values, "imageHeight");
        return this;
      }
    }

    public Criteria andImageHeightIn(List<java.lang.Integer> values) {

      if (values.size() == 1) {
        return andImageHeightEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.ImageHeight + " in", values, "imageHeight");
        return this;
      }
    }

    public Criteria andImageHeightNotIn(List<java.lang.Integer> values) {
      if (values.size() == 1) {
        return andImageHeightNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.ImageHeight + " not in", values, "imageHeight");
        return this;
      }
    }

    public Criteria andImageHeightIn(java.lang.Integer[] values) {

      if (values.length == 1) {
        return andImageHeightEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.ImageHeight + " in", Arrays.asList(values), "imageHeight");
        return this;
      }
    }

    public Criteria andImageHeightNotIn(java.lang.Integer[] values) {
      if (values.length == 1) {
        return andImageHeightNotEqualTo(values[0]);
      } else {
        addCriterion(
            IProductUIImageDAO.ImageHeight + " not in", Arrays.asList(values), "imageHeight");
        return this;
      }
    }

    public Criteria andImageHeightIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageHeight + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageHeightNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageHeight + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageHeightBetween(int value1, int value2) {
      addCriterion(IProductUIImageDAO.ImageHeight + " between", value1, value2, "imageHeight");
      return this;
    }

    public Criteria andImageHeightBetween(java.lang.Integer value1, java.lang.Integer value2) {
      addCriterion(IProductUIImageDAO.ImageHeight + " between", value1, value2, "imageHeight");
      return this;
    }

    public Criteria andImageHeightNotBetween(int value1, int value2) {
      addCriterion(IProductUIImageDAO.ImageHeight + " not between", value1, value2, "imageHeight");
      return this;
    }

    public Criteria andImageHeightNotBetween(java.lang.Integer value1, java.lang.Integer value2) {
      addCriterion(IProductUIImageDAO.ImageHeight + " not between", value1, value2, "imageHeight");
      return this;
    }

    public Criteria andImageTypeIsNull() {
      addCriterion(IProductUIImageDAO.ImageType + " is null");
      return this;
    }

    public Criteria andImageTypeIsNotNull() {
      addCriterion(IProductUIImageDAO.ImageType + " is not null");
      return this;
    }

    public Criteria andImageTypeIsNotEmpty() {
      addCriterion(
          IProductUIImageDAO.ImageType
              + " is not null AND "
              + IProductUIImageDAO.ImageType
              + " <> ''");
      return this;
    }

    public Criteria andImageTypeIsEmpty() {
      addCriterion(
          "("
              + IProductUIImageDAO.ImageType
              + " is null OR "
              + IProductUIImageDAO.ImageType
              + " = '')");
      return this;
    }

    public Criteria andImageTypeEqualTo(String value) {

      addCriterion(IProductUIImageDAO.ImageType + " = ", value, "imageType");
      return this;
    }

    public Criteria andImageTypeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageType);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageTypeEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageType + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageTypeNotEqualTo(String value) {

      addCriterion(IProductUIImageDAO.ImageType + " <>", value, "imageType");
      return this;
    }

    public Criteria andImageTypeNotEqualToOrIsNull(String value) {

      addCriterion(
          IProductUIImageDAO.ImageType + " is null OR " + IProductUIImageDAO.ImageType + " <>",
          value,
          "imageType");
      return this;
    }

    public Criteria andImageTypeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageType);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageTypeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageType + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageTypeGreaterThan(String value) {

      addCriterion(IProductUIImageDAO.ImageType + " >", value, "imageType");
      return this;
    }

    public Criteria andImageTypeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageType);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageTypeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageType + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageTypeGreaterThanOrEqualTo(String value) {

      addCriterion(IProductUIImageDAO.ImageType + " >=", value, "imageType");
      return this;
    }

    public Criteria andImageTypeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageType);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageTypeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageType + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageTypeLessThan(String value) {

      addCriterion(IProductUIImageDAO.ImageType + " <", value, "imageType");
      return this;
    }

    public Criteria andImageTypeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageType);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageTypeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageType + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageTypeLessThanOrEqualTo(String value) {

      addCriterion(IProductUIImageDAO.ImageType + " <=", value, "imageType");
      return this;
    }

    public Criteria andImageTypeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageType);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageTypeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageType + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageTypeLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUIImageDAO.ImageType + " like", buffer.toString(), "imageType");
      return this;
    }

    public Criteria andImageTypeNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUIImageDAO.ImageType + " not like", buffer.toString(), "imageType");
      return this;
    }

    public Criteria andImageTypeIn(List<String> values) {

      if (values.size() == 1) {
        return andImageTypeEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.ImageType + " in", values, "imageType");
        return this;
      }
    }

    public Criteria andImageTypeNotIn(List<String> values) {
      if (values.size() == 1) {
        return andImageTypeNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.ImageType + " not in", values, "imageType");
        return this;
      }
    }

    public Criteria andImageTypeIn(String[] values) {

      if (values.length == 1) {
        return andImageTypeEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.ImageType + " in", Arrays.asList(values), "imageType");
        return this;
      }
    }

    public Criteria andImageTypeNotIn(String[] values) {
      if (values.length == 1) {
        return andImageTypeNotEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.ImageType + " not in", Arrays.asList(values), "imageType");
        return this;
      }
    }

    public Criteria andImageTypeIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageType + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageTypeNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageType + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageTypeBetween(String value1, String value2) {
      addCriterion(IProductUIImageDAO.ImageType + " between", value1, value2, "imageType");
      return this;
    }

    public Criteria andImageTypeNotBetween(String value1, String value2) {
      addCriterion(IProductUIImageDAO.ImageType + " not between", value1, value2, "imageType");
      return this;
    }

    public Criteria andLastModifyUserIsNull() {
      addCriterion(IProductUIImageDAO.LastModifyUser + " is null");
      return this;
    }

    public Criteria andLastModifyUserIsNotNull() {
      addCriterion(IProductUIImageDAO.LastModifyUser + " is not null");
      return this;
    }

    public Criteria andLastModifyUserIsNotEmpty() {
      addCriterion(
          IProductUIImageDAO.LastModifyUser
              + " is not null AND "
              + IProductUIImageDAO.LastModifyUser
              + " <> ''");
      return this;
    }

    public Criteria andLastModifyUserIsEmpty() {
      addCriterion(
          "("
              + IProductUIImageDAO.LastModifyUser
              + " is null OR "
              + IProductUIImageDAO.LastModifyUser
              + " = '')");
      return this;
    }

    public Criteria andLastModifyUserEqualTo(String value) {

      addCriterion(IProductUIImageDAO.LastModifyUser + " = ", value, "lastModifyUser");
      return this;
    }

    public Criteria andLastModifyUserEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.LastModifyUser);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyUserEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.LastModifyUser + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyUserNotEqualTo(String value) {

      addCriterion(IProductUIImageDAO.LastModifyUser + " <>", value, "lastModifyUser");
      return this;
    }

    public Criteria andLastModifyUserNotEqualToOrIsNull(String value) {

      addCriterion(
          IProductUIImageDAO.LastModifyUser
              + " is null OR "
              + IProductUIImageDAO.LastModifyUser
              + " <>",
          value,
          "lastModifyUser");
      return this;
    }

    public Criteria andLastModifyUserNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.LastModifyUser);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyUserNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.LastModifyUser + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyUserGreaterThan(String value) {

      addCriterion(IProductUIImageDAO.LastModifyUser + " >", value, "lastModifyUser");
      return this;
    }

    public Criteria andLastModifyUserGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.LastModifyUser);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyUserGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.LastModifyUser + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyUserGreaterThanOrEqualTo(String value) {

      addCriterion(IProductUIImageDAO.LastModifyUser + " >=", value, "lastModifyUser");
      return this;
    }

    public Criteria andLastModifyUserGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.LastModifyUser);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyUserGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.LastModifyUser + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyUserLessThan(String value) {

      addCriterion(IProductUIImageDAO.LastModifyUser + " <", value, "lastModifyUser");
      return this;
    }

    public Criteria andLastModifyUserLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.LastModifyUser);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyUserLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.LastModifyUser + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyUserLessThanOrEqualTo(String value) {

      addCriterion(IProductUIImageDAO.LastModifyUser + " <=", value, "lastModifyUser");
      return this;
    }

    public Criteria andLastModifyUserLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.LastModifyUser);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyUserLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.LastModifyUser + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyUserLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IProductUIImageDAO.LastModifyUser + " like", buffer.toString(), "lastModifyUser");
      return this;
    }

    public Criteria andLastModifyUserNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IProductUIImageDAO.LastModifyUser + " not like", buffer.toString(), "lastModifyUser");
      return this;
    }

    public Criteria andLastModifyUserIn(List<String> values) {

      if (values.size() == 1) {
        return andLastModifyUserEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.LastModifyUser + " in", values, "lastModifyUser");
        return this;
      }
    }

    public Criteria andLastModifyUserNotIn(List<String> values) {
      if (values.size() == 1) {
        return andLastModifyUserNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.LastModifyUser + " not in", values, "lastModifyUser");
        return this;
      }
    }

    public Criteria andLastModifyUserIn(String[] values) {

      if (values.length == 1) {
        return andLastModifyUserEqualTo(values[0]);
      } else {
        addCriterion(
            IProductUIImageDAO.LastModifyUser + " in", Arrays.asList(values), "lastModifyUser");
        return this;
      }
    }

    public Criteria andLastModifyUserNotIn(String[] values) {
      if (values.length == 1) {
        return andLastModifyUserNotEqualTo(values[0]);
      } else {
        addCriterion(
            IProductUIImageDAO.LastModifyUser + " not in", Arrays.asList(values), "lastModifyUser");
        return this;
      }
    }

    public Criteria andLastModifyUserIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.LastModifyUser + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyUserNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.LastModifyUser + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyUserBetween(String value1, String value2) {
      addCriterion(
          IProductUIImageDAO.LastModifyUser + " between", value1, value2, "lastModifyUser");
      return this;
    }

    public Criteria andLastModifyUserNotBetween(String value1, String value2) {
      addCriterion(
          IProductUIImageDAO.LastModifyUser + " not between", value1, value2, "lastModifyUser");
      return this;
    }

    public Criteria andLastModifyTimeIsNull() {
      addCriterion(IProductUIImageDAO.LastModifyTime + " is null");
      return this;
    }

    public Criteria andLastModifyTimeIsNotNull() {
      addCriterion(IProductUIImageDAO.LastModifyTime + " is not null");
      return this;
    }

    public Criteria andLastModifyTimeIsNotEmpty() {
      addCriterion(
          IProductUIImageDAO.LastModifyTime
              + " is not null AND "
              + IProductUIImageDAO.LastModifyTime
              + " <> ''");
      return this;
    }

    public Criteria andLastModifyTimeIsEmpty() {
      addCriterion(
          "("
              + IProductUIImageDAO.LastModifyTime
              + " is null OR "
              + IProductUIImageDAO.LastModifyTime
              + " = '')");
      return this;
    }

    public Criteria andLastModifyTimeEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(IProductUIImageDAO.LastModifyTime + " = ", value, "lastModifyTime");
      return this;
    }

    public Criteria andLastModifyTimeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.LastModifyTime);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyTimeEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.LastModifyTime + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyTimeNotEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(IProductUIImageDAO.LastModifyTime + " <>", value, "lastModifyTime");
      return this;
    }

    public Criteria andLastModifyTimeNotEqualToOrIsNull(java.util.Date value) {

      addCriterionForJDBCDate(
          IProductUIImageDAO.LastModifyTime
              + " is null OR "
              + IProductUIImageDAO.LastModifyTime
              + " <>",
          value,
          "lastModifyTime");
      return this;
    }

    public Criteria andLastModifyTimeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.LastModifyTime);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyTimeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.LastModifyTime + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyTimeGreaterThan(java.util.Date value) {

      addCriterionForJDBCDate(IProductUIImageDAO.LastModifyTime + " >", value, "lastModifyTime");
      return this;
    }

    public Criteria andLastModifyTimeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.LastModifyTime);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyTimeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.LastModifyTime + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyTimeGreaterThanOrEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(IProductUIImageDAO.LastModifyTime + " >=", value, "lastModifyTime");
      return this;
    }

    public Criteria andLastModifyTimeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.LastModifyTime);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyTimeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.LastModifyTime + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyTimeLessThan(java.util.Date value) {

      addCriterionForJDBCDate(IProductUIImageDAO.LastModifyTime + " <", value, "lastModifyTime");
      return this;
    }

    public Criteria andLastModifyTimeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.LastModifyTime);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyTimeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.LastModifyTime + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyTimeLessThanOrEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(IProductUIImageDAO.LastModifyTime + " <=", value, "lastModifyTime");
      return this;
    }

    public Criteria andLastModifyTimeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.LastModifyTime);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyTimeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.LastModifyTime + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyTimeIn(List<java.util.Date> values) {

      if (values.size() == 1) {
        return andLastModifyTimeEqualTo(values.get(0));
      } else {
        addCriterionForJDBCDate(
            IProductUIImageDAO.LastModifyTime + " in", values, "lastModifyTime");
        return this;
      }
    }

    public Criteria andLastModifyTimeNotIn(List<java.util.Date> values) {
      if (values.size() == 1) {
        return andLastModifyTimeNotEqualTo(values.get(0));
      } else {
        addCriterionForJDBCDate(
            IProductUIImageDAO.LastModifyTime + " not in", values, "lastModifyTime");
        return this;
      }
    }

    public Criteria andLastModifyTimeIn(java.util.Date[] values) {

      if (values.length == 1) {
        return andLastModifyTimeEqualTo(values[0]);
      } else {
        addCriterionForJDBCDate(
            IProductUIImageDAO.LastModifyTime + " in", Arrays.asList(values), "lastModifyTime");
        return this;
      }
    }

    public Criteria andLastModifyTimeNotIn(java.util.Date[] values) {
      if (values.length == 1) {
        return andLastModifyTimeNotEqualTo(values[0]);
      } else {
        addCriterionForJDBCDate(
            IProductUIImageDAO.LastModifyTime + " not in", Arrays.asList(values), "lastModifyTime");
        return this;
      }
    }

    public Criteria andLastModifyTimeIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.LastModifyTime + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyTimeNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.LastModifyTime + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyTimeBetween(java.util.Date value1, java.util.Date value2) {
      addCriterionForJDBCDate(
          IProductUIImageDAO.LastModifyTime + " between", value1, value2, "lastModifyTime");
      return this;
    }

    public Criteria andLastModifyTimeNotBetween(java.util.Date value1, java.util.Date value2) {
      addCriterionForJDBCDate(
          IProductUIImageDAO.LastModifyTime + " not between", value1, value2, "lastModifyTime");
      return this;
    }

    public Criteria andStatusIsNull() {
      addCriterion(IProductUIImageDAO.Status + " is null");
      return this;
    }

    public Criteria andStatusIsNotNull() {
      addCriterion(IProductUIImageDAO.Status + " is not null");
      return this;
    }

    public Criteria andStatusIsNotEmpty() {
      addCriterion(
          IProductUIImageDAO.Status + " is not null AND " + IProductUIImageDAO.Status + " <> ''");
      return this;
    }

    public Criteria andStatusIsEmpty() {
      addCriterion(
          "(" + IProductUIImageDAO.Status + " is null OR " + IProductUIImageDAO.Status + " = '')");
      return this;
    }

    public Criteria andStatusEqualTo(String value) {

      addCriterion(IProductUIImageDAO.Status + " = ", value, "status");
      return this;
    }

    public Criteria andStatusEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Status);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Status + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotEqualTo(String value) {

      addCriterion(IProductUIImageDAO.Status + " <>", value, "status");
      return this;
    }

    public Criteria andStatusNotEqualToOrIsNull(String value) {

      addCriterion(
          IProductUIImageDAO.Status + " is null OR " + IProductUIImageDAO.Status + " <>",
          value,
          "status");
      return this;
    }

    public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Status);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Status + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThan(String value) {

      addCriterion(IProductUIImageDAO.Status + " >", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Status);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Status + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(String value) {

      addCriterion(IProductUIImageDAO.Status + " >=", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Status);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Status + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThan(String value) {

      addCriterion(IProductUIImageDAO.Status + " <", value, "status");
      return this;
    }

    public Criteria andStatusLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Status);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Status + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(String value) {

      addCriterion(IProductUIImageDAO.Status + " <=", value, "status");
      return this;
    }

    public Criteria andStatusLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Status);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Status + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUIImageDAO.Status + " like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUIImageDAO.Status + " not like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusIn(List<String> values) {

      if (values.size() == 1) {
        return andStatusEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.Status + " in", values, "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(List<String> values) {
      if (values.size() == 1) {
        return andStatusNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.Status + " not in", values, "status");
        return this;
      }
    }

    public Criteria andStatusIn(String[] values) {

      if (values.length == 1) {
        return andStatusEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.Status + " in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(String[] values) {
      if (values.length == 1) {
        return andStatusNotEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.Status + " not in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Status + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Status + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusBetween(String value1, String value2) {
      addCriterion(IProductUIImageDAO.Status + " between", value1, value2, "status");
      return this;
    }

    public Criteria andStatusNotBetween(String value1, String value2) {
      addCriterion(IProductUIImageDAO.Status + " not between", value1, value2, "status");
      return this;
    }

    public Criteria andRemarksIsNull() {
      addCriterion(IProductUIImageDAO.Remarks + " is null");
      return this;
    }

    public Criteria andRemarksIsNotNull() {
      addCriterion(IProductUIImageDAO.Remarks + " is not null");
      return this;
    }

    public Criteria andRemarksIsNotEmpty() {
      addCriterion(
          IProductUIImageDAO.Remarks + " is not null AND " + IProductUIImageDAO.Remarks + " <> ''");
      return this;
    }

    public Criteria andRemarksIsEmpty() {
      addCriterion(
          "("
              + IProductUIImageDAO.Remarks
              + " is null OR "
              + IProductUIImageDAO.Remarks
              + " = '')");
      return this;
    }

    public Criteria andRemarksEqualTo(String value) {

      addCriterion(IProductUIImageDAO.Remarks + " = ", value, "remarks");
      return this;
    }

    public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Remarks);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Remarks + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotEqualTo(String value) {

      addCriterion(IProductUIImageDAO.Remarks + " <>", value, "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToOrIsNull(String value) {

      addCriterion(
          IProductUIImageDAO.Remarks + " is null OR " + IProductUIImageDAO.Remarks + " <>",
          value,
          "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Remarks);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Remarks + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThan(String value) {

      addCriterion(IProductUIImageDAO.Remarks + " >", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Remarks);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Remarks + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(String value) {

      addCriterion(IProductUIImageDAO.Remarks + " >=", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Remarks);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Remarks + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThan(String value) {

      addCriterion(IProductUIImageDAO.Remarks + " <", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Remarks);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Remarks + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(String value) {

      addCriterion(IProductUIImageDAO.Remarks + " <=", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.Remarks);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Remarks + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUIImageDAO.Remarks + " like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUIImageDAO.Remarks + " not like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksIn(List<String> values) {

      if (values.size() == 1) {
        return andRemarksEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.Remarks + " in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(List<String> values) {
      if (values.size() == 1) {
        return andRemarksNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.Remarks + " not in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(String[] values) {

      if (values.length == 1) {
        return andRemarksEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.Remarks + " in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(String[] values) {
      if (values.length == 1) {
        return andRemarksNotEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.Remarks + " not in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Remarks + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.Remarks + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksBetween(String value1, String value2) {
      addCriterion(IProductUIImageDAO.Remarks + " between", value1, value2, "remarks");
      return this;
    }

    public Criteria andRemarksNotBetween(String value1, String value2) {
      addCriterion(IProductUIImageDAO.Remarks + " not between", value1, value2, "remarks");
      return this;
    }

    public Criteria andImageContentIsNull() {
      addCriterion(IProductUIImageDAO.ImageContent + " is null");
      return this;
    }

    public Criteria andImageContentIsNotNull() {
      addCriterion(IProductUIImageDAO.ImageContent + " is not null");
      return this;
    }

    public Criteria andImageContentIsNotEmpty() {
      addCriterion(
          IProductUIImageDAO.ImageContent
              + " is not null AND "
              + IProductUIImageDAO.ImageContent
              + " <> ''");
      return this;
    }

    public Criteria andImageContentIsEmpty() {
      addCriterion(
          "("
              + IProductUIImageDAO.ImageContent
              + " is null OR "
              + IProductUIImageDAO.ImageContent
              + " = '')");
      return this;
    }

    public Criteria andImageContentEqualTo(byte[] value) {

      addCriterion(IProductUIImageDAO.ImageContent + " = ", value, "imageContent");
      return this;
    }

    public Criteria andImageContentEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageContent);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageContentEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageContent + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageContentNotEqualTo(byte[] value) {

      addCriterion(IProductUIImageDAO.ImageContent + " <>", value, "imageContent");
      return this;
    }

    public Criteria andImageContentNotEqualToOrIsNull(byte[] value) {

      addCriterion(
          IProductUIImageDAO.ImageContent
              + " is null OR "
              + IProductUIImageDAO.ImageContent
              + " <>",
          value,
          "imageContent");
      return this;
    }

    public Criteria andImageContentNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageContent);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageContentNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageContent + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageContentGreaterThan(byte[] value) {

      addCriterion(IProductUIImageDAO.ImageContent + " >", value, "imageContent");
      return this;
    }

    public Criteria andImageContentGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageContent);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageContentGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageContent + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageContentGreaterThanOrEqualTo(byte[] value) {

      addCriterion(IProductUIImageDAO.ImageContent + " >=", value, "imageContent");
      return this;
    }

    public Criteria andImageContentGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageContent);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageContentGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageContent + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageContentLessThan(byte[] value) {

      addCriterion(IProductUIImageDAO.ImageContent + " <", value, "imageContent");
      return this;
    }

    public Criteria andImageContentLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageContent);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageContentLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageContent + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageContentLessThanOrEqualTo(byte[] value) {

      addCriterion(IProductUIImageDAO.ImageContent + " <=", value, "imageContent");
      return this;
    }

    public Criteria andImageContentLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.ImageContent);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andImageContentLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageContent + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageContentIn(List<byte[]> values) {

      if (values.size() == 1) {
        return andImageContentEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.ImageContent + " in", values, "imageContent");
        return this;
      }
    }

    public Criteria andImageContentNotIn(List<byte[]> values) {
      if (values.size() == 1) {
        return andImageContentNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.ImageContent + " not in", values, "imageContent");
        return this;
      }
    }

    public Criteria andImageContentIn(byte[][] values) {

      if (values.length == 1) {
        return andImageContentEqualTo(values[0]);
      } else {
        addCriterion(
            IProductUIImageDAO.ImageContent + " in", Arrays.asList(values), "imageContent");
        return this;
      }
    }

    public Criteria andImageContentNotIn(byte[][] values) {
      if (values.length == 1) {
        return andImageContentNotEqualTo(values[0]);
      } else {
        addCriterion(
            IProductUIImageDAO.ImageContent + " not in", Arrays.asList(values), "imageContent");
        return this;
      }
    }

    public Criteria andImageContentIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageContent + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageContentNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.ImageContent + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andImageContentBetween(byte[] value1, byte[] value2) {
      addCriterion(IProductUIImageDAO.ImageContent + " between", value1, value2, "imageContent");
      return this;
    }

    public Criteria andImageContentNotBetween(byte[] value1, byte[] value2) {
      addCriterion(
          IProductUIImageDAO.ImageContent + " not between", value1, value2, "imageContent");
      return this;
    }

    public Criteria andDomainCodeIsNull() {
      addCriterion(IProductUIImageDAO.DomainCode + " is null");
      return this;
    }

    public Criteria andDomainCodeIsNotNull() {
      addCriterion(IProductUIImageDAO.DomainCode + " is not null");
      return this;
    }

    public Criteria andDomainCodeIsNotEmpty() {
      addCriterion(
          IProductUIImageDAO.DomainCode
              + " is not null AND "
              + IProductUIImageDAO.DomainCode
              + " <> ''");
      return this;
    }

    public Criteria andDomainCodeIsEmpty() {
      addCriterion(
          "("
              + IProductUIImageDAO.DomainCode
              + " is null OR "
              + IProductUIImageDAO.DomainCode
              + " = '')");
      return this;
    }

    public Criteria andDomainCodeEqualTo(String value) {

      addCriterion(IProductUIImageDAO.DomainCode + " = ", value, "domainCode");
      return this;
    }

    public Criteria andDomainCodeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainCode);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainCodeEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainCode + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainCodeNotEqualTo(String value) {

      addCriterion(IProductUIImageDAO.DomainCode + " <>", value, "domainCode");
      return this;
    }

    public Criteria andDomainCodeNotEqualToOrIsNull(String value) {

      addCriterion(
          IProductUIImageDAO.DomainCode + " is null OR " + IProductUIImageDAO.DomainCode + " <>",
          value,
          "domainCode");
      return this;
    }

    public Criteria andDomainCodeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainCode);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainCodeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainCode + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainCodeGreaterThan(String value) {

      addCriterion(IProductUIImageDAO.DomainCode + " >", value, "domainCode");
      return this;
    }

    public Criteria andDomainCodeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainCode);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainCodeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainCode + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainCodeGreaterThanOrEqualTo(String value) {

      addCriterion(IProductUIImageDAO.DomainCode + " >=", value, "domainCode");
      return this;
    }

    public Criteria andDomainCodeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainCode);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainCodeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainCode + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainCodeLessThan(String value) {

      addCriterion(IProductUIImageDAO.DomainCode + " <", value, "domainCode");
      return this;
    }

    public Criteria andDomainCodeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainCode);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainCodeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainCode + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainCodeLessThanOrEqualTo(String value) {

      addCriterion(IProductUIImageDAO.DomainCode + " <=", value, "domainCode");
      return this;
    }

    public Criteria andDomainCodeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainCode);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainCodeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainCode + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainCodeLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUIImageDAO.DomainCode + " like", buffer.toString(), "domainCode");
      return this;
    }

    public Criteria andDomainCodeNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUIImageDAO.DomainCode + " not like", buffer.toString(), "domainCode");
      return this;
    }

    public Criteria andDomainCodeIn(List<String> values) {

      if (values.size() == 1) {
        return andDomainCodeEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.DomainCode + " in", values, "domainCode");
        return this;
      }
    }

    public Criteria andDomainCodeNotIn(List<String> values) {
      if (values.size() == 1) {
        return andDomainCodeNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.DomainCode + " not in", values, "domainCode");
        return this;
      }
    }

    public Criteria andDomainCodeIn(String[] values) {

      if (values.length == 1) {
        return andDomainCodeEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.DomainCode + " in", Arrays.asList(values), "domainCode");
        return this;
      }
    }

    public Criteria andDomainCodeNotIn(String[] values) {
      if (values.length == 1) {
        return andDomainCodeNotEqualTo(values[0]);
      } else {
        addCriterion(
            IProductUIImageDAO.DomainCode + " not in", Arrays.asList(values), "domainCode");
        return this;
      }
    }

    public Criteria andDomainCodeIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainCode + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainCodeNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainCode + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainCodeBetween(String value1, String value2) {
      addCriterion(IProductUIImageDAO.DomainCode + " between", value1, value2, "domainCode");
      return this;
    }

    public Criteria andDomainCodeNotBetween(String value1, String value2) {
      addCriterion(IProductUIImageDAO.DomainCode + " not between", value1, value2, "domainCode");
      return this;
    }

    public Criteria andDomainNameIsNull() {
      addCriterion(IProductUIImageDAO.DomainName + " is null");
      return this;
    }

    public Criteria andDomainNameIsNotNull() {
      addCriterion(IProductUIImageDAO.DomainName + " is not null");
      return this;
    }

    public Criteria andDomainNameIsNotEmpty() {
      addCriterion(
          IProductUIImageDAO.DomainName
              + " is not null AND "
              + IProductUIImageDAO.DomainName
              + " <> ''");
      return this;
    }

    public Criteria andDomainNameIsEmpty() {
      addCriterion(
          "("
              + IProductUIImageDAO.DomainName
              + " is null OR "
              + IProductUIImageDAO.DomainName
              + " = '')");
      return this;
    }

    public Criteria andDomainNameEqualTo(String value) {

      addCriterion(IProductUIImageDAO.DomainName + " = ", value, "domainName");
      return this;
    }

    public Criteria andDomainNameEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainName);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainNameEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainName + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainNameNotEqualTo(String value) {

      addCriterion(IProductUIImageDAO.DomainName + " <>", value, "domainName");
      return this;
    }

    public Criteria andDomainNameNotEqualToOrIsNull(String value) {

      addCriterion(
          IProductUIImageDAO.DomainName + " is null OR " + IProductUIImageDAO.DomainName + " <>",
          value,
          "domainName");
      return this;
    }

    public Criteria andDomainNameNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainName);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainNameNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainName + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainNameGreaterThan(String value) {

      addCriterion(IProductUIImageDAO.DomainName + " >", value, "domainName");
      return this;
    }

    public Criteria andDomainNameGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainName);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainNameGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainName + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainNameGreaterThanOrEqualTo(String value) {

      addCriterion(IProductUIImageDAO.DomainName + " >=", value, "domainName");
      return this;
    }

    public Criteria andDomainNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainName);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainNameGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainName + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainNameLessThan(String value) {

      addCriterion(IProductUIImageDAO.DomainName + " <", value, "domainName");
      return this;
    }

    public Criteria andDomainNameLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainName);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainNameLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainName + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainNameLessThanOrEqualTo(String value) {

      addCriterion(IProductUIImageDAO.DomainName + " <=", value, "domainName");
      return this;
    }

    public Criteria andDomainNameLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IProductUIImageDAO.DomainName);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDomainNameLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainName + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainNameLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUIImageDAO.DomainName + " like", buffer.toString(), "domainName");
      return this;
    }

    public Criteria andDomainNameNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IProductUIImageDAO.DomainName + " not like", buffer.toString(), "domainName");
      return this;
    }

    public Criteria andDomainNameIn(List<String> values) {

      if (values.size() == 1) {
        return andDomainNameEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.DomainName + " in", values, "domainName");
        return this;
      }
    }

    public Criteria andDomainNameNotIn(List<String> values) {
      if (values.size() == 1) {
        return andDomainNameNotEqualTo(values.get(0));
      } else {
        addCriterion(IProductUIImageDAO.DomainName + " not in", values, "domainName");
        return this;
      }
    }

    public Criteria andDomainNameIn(String[] values) {

      if (values.length == 1) {
        return andDomainNameEqualTo(values[0]);
      } else {
        addCriterion(IProductUIImageDAO.DomainName + " in", Arrays.asList(values), "domainName");
        return this;
      }
    }

    public Criteria andDomainNameNotIn(String[] values) {
      if (values.length == 1) {
        return andDomainNameNotEqualTo(values[0]);
      } else {
        addCriterion(
            IProductUIImageDAO.DomainName + " not in", Arrays.asList(values), "domainName");
        return this;
      }
    }

    public Criteria andDomainNameIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainName + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainNameNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IProductUIImageDAO.DomainName + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDomainNameBetween(String value1, String value2) {
      addCriterion(IProductUIImageDAO.DomainName + " between", value1, value2, "domainName");
      return this;
    }

    public Criteria andDomainNameNotBetween(String value1, String value2) {
      addCriterion(IProductUIImageDAO.DomainName + " not between", value1, value2, "domainName");
      return this;
    }
  }
}
